home *** CD-ROM | disk | FTP | other *** search
/ PD Collection CD 1 / PD Collection CD 1.iso / textual / tex / files / !tex / TeXsource / commontex / c / eq < prev    next >
Encoding:
Text File  |  1988-04-18  |  18.1 KB  |  616 lines
  1. /*
  2.  *    Copyright 1986, 1987 Pat Joseph Monardo. All rights reserved.
  3.  *    Copying of this file is granted according to the provisions 
  4.  *    specified in the file COPYING which must accompany this file.
  5.  */
  6.  
  7.  
  8. /*
  9.  *              eq.c
  10.  */
  11.  
  12. #include "tex.h"
  13. #include "cmds.h"
  14. #include "heap.h"
  15. #include "char.h"
  16. #include "token.h"
  17. #include "hash.h"
  18. #include "box.h"
  19. #include "print.h"
  20. #include "error.h"
  21. #include "eq.h"
  22.  
  23. mword   eqtb[EQTB_SIZE+1];
  24. qword   xeq_level[EQTB_SIZE+1 - INT_BASE];
  25.  
  26. print_skip_param (n)
  27.         int             n;
  28. {
  29.         switch (n)
  30.         {
  31.         case LINE_SKIP_CODE:
  32.                 print_esc("lineskip"); 
  33.                 break;
  34.  
  35.         case BASELINE_SKIP_CODE:
  36.                 print_esc("baselineskip"); 
  37.                 break;
  38.  
  39.         case PAR_SKIP_CODE:
  40.                 print_esc("parskip"); 
  41.                 break;
  42.  
  43.         case ABOVE_DISPLAY_SKIP_CODE:
  44.                 print_esc("abovedisplayskip"); 
  45.                 break;
  46.  
  47.         case BELOW_DISPLAY_SKIP_CODE:
  48.                 print_esc("belowdisplayskip"); 
  49.                 break;
  50.  
  51.         case ABOVE_DISPLAY_SHORT_SKIP_CODE:
  52.                 print_esc("abovedisplayshortskip"); 
  53.                 break;
  54.  
  55.         case BELOW_DISPLAY_SHORT_SKIP_CODE:
  56.                 print_esc("belowdisplayshortskip"); 
  57.                 break;
  58.  
  59.         case LEFT_SKIP_CODE:
  60.                 print_esc("leftskip"); 
  61.                 break;
  62.  
  63.         case RIGHT_SKIP_CODE:
  64.                 print_esc("rightskip"); 
  65.                 break;
  66.  
  67.         case TOP_SKIP_CODE:
  68.                 print_esc("topskip"); 
  69.                 break;
  70.  
  71.         case SPLIT_TOP_SKIP_CODE:
  72.                 print_esc("splittopskip"); 
  73.                 break;
  74.  
  75.         case TAB_SKIP_CODE:
  76.                 print_esc("tabskip"); 
  77.                 break;
  78.  
  79.         case SPACE_SKIP_CODE:
  80.                 print_esc("spaceskip"); 
  81.                 break;
  82.  
  83.         case XSPACE_SKIP_CODE:
  84.                 print_esc("xspaceskip"); 
  85.                 break;
  86.  
  87.         case PAR_FILL_SKIP_CODE:
  88.                 print_esc("parfillskip"); 
  89.                 break;
  90.  
  91.         case THIN_MU_SKIP_CODE:
  92.                 print_esc("thinmuskip"); 
  93.                 break;
  94.  
  95.         case MED_MU_SKIP_CODE:
  96.                 print_esc("medmuskip"); 
  97.                 break;
  98.  
  99.         case THICK_MU_SKIP_CODE:
  100.                 print_esc("thickmuskip"); 
  101.                 break;
  102.  
  103.         default:
  104.                 print("[unknown glue parameter!]"); 
  105.                 break;
  106.         }
  107. }
  108.  
  109. print_param (n)
  110.         int             n;
  111. {
  112.         switch (n)
  113.         {
  114.         case PRETOLERANCE_CODE:
  115.                 print_esc("pretolerance"); 
  116.                 break;
  117.  
  118.         case TOLERANCE_CODE:
  119.                 print_esc("tolerance"); 
  120.                 break;
  121.  
  122.         case LINE_PENALTY_CODE:
  123.                 print_esc("linepenalty"); 
  124.                 break;
  125.  
  126.         case HYPHEN_PENALTY_CODE:
  127.                 print_esc("hyphenpenalty"); 
  128.                 break;
  129.  
  130.         case EX_HYPHEN_PENALTY_CODE:
  131.                 print_esc("exhyphenpenalty"); 
  132.                 break;
  133.  
  134.         case CLUB_PENALTY_CODE:
  135.                 print_esc("clubpenalty"); 
  136.                 break;
  137.  
  138.         case WIDOW_PENALTY_CODE:
  139.                 print_esc("widowpenalty"); 
  140.                 break;
  141.  
  142.         case DISPLAY_WIDOW_PENALTY_CODE:
  143.                 print_esc("displaywidowpenalty"); 
  144.                 break;
  145.  
  146.         case BROKEN_PENALTY_CODE:
  147.                 print_esc("brokenpenalty"); 
  148.                 break;
  149.  
  150.         case BIN_OP_PENALTY_CODE:
  151.                 print_esc("binoppenalty"); 
  152.                 break;
  153.  
  154.         case REL_PENALTY_CODE:
  155.                 print_esc("relpenalty"); 
  156.                 break;
  157.  
  158.         case PRE_DISPLAY_PENALTY_CODE:
  159.                 print_esc("predisplaypenalty"); 
  160.                 break;
  161.  
  162.         case POST_DISPLAY_PENALTY_CODE:
  163.                 print_esc("postdisplaypenalty"); 
  164.                 break;
  165.  
  166.         case INTER_LINE_PENALTY_CODE:
  167.                 print_esc("interlinepenalty"); 
  168.                 break;
  169.  
  170.         case DOUBLE_HYPHEN_DEMERITS_CODE:
  171.                 print_esc("doublehyphendemerits"); 
  172.                 break;
  173.  
  174.         case FINAL_HYPHEN_DEMERITS_CODE:
  175.                 print_esc("finalhyphendemerits"); 
  176.                 break;
  177.  
  178.         case ADJ_DEMERITS_CODE:
  179.                 print_esc("adjdemerits"); 
  180.                 break;
  181.  
  182.         case MAG_CODE:
  183.                 print_esc("mag"); 
  184.                 break;
  185.  
  186.         case DELIMITER_FACTOR_CODE:
  187.                 print_esc("delimiterfactor"); 
  188.                 break;
  189.  
  190.         case LOOSENESS_CODE:
  191.                 print_esc("looseness"); 
  192.                 break;
  193.  
  194.         case TIME_CODE:
  195.                 print_esc("time"); 
  196.                 break;
  197.  
  198.         case DAY_CODE:
  199.                 print_esc("day"); 
  200.                 break;
  201.  
  202.         case MONTH_CODE:
  203.                 print_esc("month"); 
  204.                 break;
  205.  
  206.         case YEAR_CODE:
  207.                 print_esc("year"); 
  208.                 break;
  209.  
  210.         case SHOW_BOX_BREADTH_CODE:
  211.                 print_esc("showboxbreadth"); 
  212.                 break;
  213.  
  214.         case SHOW_BOX_DEPTH_CODE:
  215.                 print_esc("showboxdepth"); 
  216.                 break;
  217.  
  218.         case HBADNESS_CODE:
  219.                 print_esc("hbadness"); 
  220.                 break;
  221.  
  222.         case VBADNESS_CODE:
  223.                 print_esc("vbadness"); 
  224.                 break;
  225.  
  226.         case PAUSING_CODE:
  227.                 print_esc("pause"); 
  228.                 break;
  229.  
  230.         case TRACING_ONLINE_CODE:
  231.                 print_esc("tracingonline"); 
  232.                 break;
  233.  
  234.         case TRACING_MACROS_CODE:
  235.                 print_esc("tracingmacros"); 
  236.                 break;
  237.  
  238.         case TRACING_STATS_CODE:
  239.                 print_esc("tracingstats"); 
  240.                 break;
  241.  
  242.         case TRACING_PARAGRAPHS_CODE:
  243.                 print_esc("tracingparagraphs"); 
  244.                 break;
  245.  
  246.         case TRACING_PAGES_CODE:
  247.                 print_esc("tracingpages"); 
  248.                 break;
  249.  
  250.         case TRACING_OUTPUT_CODE:
  251.                 print_esc("tracingoutput"); 
  252.                 break;
  253.  
  254.         case TRACING_LOST_CHARS_CODE:
  255.                 print_esc("tracinglostchars"); 
  256.                 break;
  257.  
  258.         case TRACING_COMMANDS_CODE:
  259.                 print_esc("tracingcommands"); 
  260.                 break;
  261.  
  262.         case TRACING_RESTORES_CODE:
  263.                 print_esc("tracingrestores"); 
  264.                 break;
  265.  
  266.         case UC_HYPH_CODE:
  267.                 print_esc("uchyph"); 
  268.                 break;
  269.  
  270.         case OUTPUT_PENALTY_CODE:
  271.                 print_esc("outputpenalty"); 
  272.                 break;
  273.  
  274.         case MAX_DEAD_CYCLES_CODE:
  275.                 print_esc("maxdeadcycles"); 
  276.                 break;
  277.  
  278.         case HANG_AFTER_CODE:
  279.                 print_esc("hangafter"); 
  280.                 break;
  281.  
  282.         case FLOATING_PENALTY_CODE:
  283.                 print_esc("floatingpenalty"); 
  284.                 break;
  285.  
  286.         case GLOBAL_DEFS_CODE:
  287.                 print_esc("globaldefs"); 
  288.                 break;
  289.  
  290.         case CUR_FAM_CODE:
  291.                 print_esc("fam"); 
  292.                 break;
  293.  
  294.         case ESCAPE_CHAR_CODE:
  295.                 print_esc("escapechar"); 
  296.                 break;
  297.  
  298.         case DEFAULT_HYPHEN_CHAR_CODE:
  299.                 print_esc("defaulthyphenchar"); 
  300.                 break;
  301.  
  302.         case DEFAULT_SKEW_CHAR_CODE:
  303.                 print_esc("defaultskewchar"); 
  304.                 break;
  305.  
  306.         case END_LINE_CHAR_CODE:
  307.                 print_esc("endlinechar"); 
  308.                 break;
  309.  
  310.         case NEW_LINE_CHAR_CODE:
  311.                 print_esc("newlinechar"); 
  312.                 break;
  313.  
  314.         default:
  315.                 print("[unknown integer parameter!]"); 
  316.                 break;
  317.         }
  318. }
  319.  
  320. print_length_param (n)
  321.         int             n;
  322. {
  323.         switch (n)
  324.         {
  325.         case PAR_INDENT_CODE:
  326.                 print_esc("parindent"); 
  327.                 break;
  328.  
  329.         case MATH_SURROUND_CODE:
  330.                 print_esc("mathsurround"); 
  331.                 break;
  332.  
  333.         case LINE_SKIP_LIMIT_CODE:
  334.                 print_esc("lineskiplimit"); 
  335.                 break;
  336.  
  337.         case HSIZE_CODE:
  338.                 print_esc("hsize"); 
  339.                 break;
  340.  
  341.         case VSIZE_CODE:
  342.                 print_esc("vsize"); 
  343.                 break;
  344.  
  345.         case MAX_DEPTH_CODE:
  346.                 print_esc("maxdepth"); 
  347.                 break;
  348.  
  349.         case SPLIT_MAX_DEPTH_CODE:
  350.                 print_esc("splitmaxdepth"); 
  351.                 break;
  352.  
  353.         case BOX_MAX_DEPTH_CODE:
  354.                 print_esc("boxmaxdepth"); 
  355.                 break;
  356.  
  357.         case HFUZZ_CODE:
  358.                 print_esc("hfuzz"); 
  359.                 break;
  360.  
  361.         case VFUZZ_CODE:
  362.                 print_esc("vfuzz"); 
  363.                 break;
  364.  
  365.         case DELIMITER_SHORTFALL_CODE:
  366.                 print_esc("delimitershortfall"); 
  367.                 break;
  368.  
  369.         case NULL_DELIMITER_SPACE_CODE:
  370.                 print_esc("nulldelimiterspace"); 
  371.                 break;
  372.  
  373.         case SCRIPT_SPACE_CODE:
  374.                 print_esc("scriptspace"); 
  375.                 break;
  376.  
  377.         case PRE_DISPLAY_SIZE_CODE:
  378.                 print_esc("predisplaysize"); 
  379.                 break;
  380.  
  381.         case DISPLAY_INDENT_CODE:
  382.                 print_esc("displayindent"); 
  383.                 break;
  384.  
  385.         case DISPLAY_WIDTH_CODE:
  386.                 print_esc("displaywidth"); 
  387.                 break;
  388.  
  389.         case OVERFULL_RULE_CODE:
  390.                 print_esc("overfullrule"); 
  391.                 break;
  392.  
  393.         case HANG_INDENT_CODE:
  394.                 print_esc("hangindent"); 
  395.                 break;
  396.  
  397.         case H_OFFSET_CODE:
  398.                 print_esc("hoffset"); 
  399.                 break;
  400.  
  401.         case V_OFFSET_CODE:
  402.                 print_esc("voffset"); 
  403.                 break;
  404.  
  405.         default:
  406.                 print("[unknown dimen parameter!]"); 
  407.                 break;
  408.         }
  409. }
  410.  
  411. #ifdef STAT
  412. show_eqtb (n)
  413.         ptr             n;
  414. {
  415.         if (n < ACTIVE_BASE)
  416.                 print_char('?');
  417.         else if (n < GLUE_BASE) {
  418.                 sprint_cs(n);
  419.                 print_char('=');
  420.                 print_cmd_chr(eq_type(n), equiv(n));
  421.                 if (eq_type(n) >= CALL) {
  422.                         print_char(':');
  423.                         show_token_list(token_link(equiv(n)), NULL, 32L);
  424.                 }
  425.         } else if (n < LOCAL_BASE) {
  426.                 if (n < SKIP_BASE) {
  427.                         print_skip_param(n - GLUE_BASE);
  428.                         print_char('=');
  429.                         if (n < GLUE_BASE + THIN_MU_SKIP_CODE)
  430.                                 print_spec(equiv(n), "pt");
  431.                         else print_spec(equiv(n), "mu");
  432.                 } else if (n < MU_SKIP_BASE) {
  433.                         print_esc("skip");
  434.                         print_int(n - SKIP_BASE); 
  435.                         print_char('=');
  436.                         print_spec(equiv(n), "pt");
  437.                 } else {
  438.                         print_esc("muskip");
  439.                         print_int(n - MU_SKIP_BASE);
  440.                         print_char('=');
  441.                         print_spec(equiv(n), "mu");
  442.                 }
  443.         } else if (n < INT_BASE) {
  444.                 if (n == PAR_SHAPE_LOC) {
  445.                         print_esc("parshape");
  446.                         print_char('=');
  447.                         if (par_shape_ptr == NULL)
  448.                                 print_char('O');
  449.                         else print_int(info(par_shape_ptr));
  450.                 } else if (n < TOKS_BASE) {
  451.                         print_cmd_chr(ASSIGN_TOKS, n);
  452.                         print_char('=');
  453.                         if (equiv(n) != NULL)
  454.                                 show_token_list(token_link(equiv(n)), NULL, 32L);
  455.                 } else if (n < BOX_BASE) {
  456.                         print_esc("toks");
  457.                         print_int(n - TOKS_BASE);
  458.                         print_char('=');
  459.                         if (equiv(n) != NULL)
  460.                                 show_token_list(token_link(equiv(n)), NULL, 32L);
  461.                 } else if (n < CUR_FONT_LOC) {
  462.                         print_esc("box");
  463.                         print_int(n - BOX_BASE);
  464.                         print_char('=');
  465.                         if (equiv(n) == NULL)
  466.                                 print("void");
  467.                         else {
  468.                                 depth_threshold = 0;
  469.                                 breadth_max = 1;
  470.                                 show_node_list(equiv(n));
  471.                         }
  472.                 } else if (n < CAT_CODE_BASE) {
  473.                         if (n == CUR_FONT_LOC)
  474.                                 print("current font");
  475.                         else if (n < MATH_FONT_BASE + 16) {
  476.                                 print_esc("textfont");
  477.                                 print_int(n - MATH_FONT_BASE);
  478.                         } else if (n < MATH_FONT_BASE + 32) {
  479.                                 print_esc("scriptfont");
  480.                                 print_int(n - MATH_FONT_BASE - 16);
  481.                         } else {
  482.                                 print_esc("scriptscritpfont");
  483.                                 print_int(n - MATH_FONT_BASE - 32);
  484.                         }
  485.                         print_char('=');
  486.                         print_esc("");
  487.                         print_str(hash[FONT_ID_BASE + equiv(n)].hh1.rh);
  488.                 } else {
  489.                         if (n < MATH_CODE_BASE) {
  490.                                 if (n < LC_CODE_BASE) {
  491.                                         print_esc("catcode");
  492.                                         print_int(n - CAT_CODE_BASE);
  493.                                 } else if (n < UC_CODE_BASE) {
  494.                                         print_esc("lccode");
  495.                                         print_int(n - LC_CODE_BASE);
  496.                                 } else if (n < SF_CODE_BASE) {
  497.                                         print_esc("uccode");
  498.                                         print_int(n - UC_CODE_BASE);
  499.                                 } else {
  500.                                         print_esc("sfcode");
  501.                                         print_int(n - SF_CODE_BASE);
  502.                                 }
  503.                                 print_char('=');
  504.                                 print_int(equiv(n));
  505.                         } else {
  506.                                 print_esc("math_code");
  507.                                 print_int(n - MATH_CODE_BASE);
  508.                                 print_char('=');
  509.                                 print_int(ho(equiv(n)));
  510.                         }
  511.                 }
  512.         } else if (n < DIMEN_BASE) {
  513.                 if (n < COUNT_BASE)
  514.                         print_param(n - INT_BASE);
  515.                 else if (n < DEL_CODE_BASE) {
  516.                         print_esc("count");
  517.                         print_int(n - COUNT_BASE);
  518.                 } else {
  519.                         print_esc("delcode");
  520.                         print_int(n - DEL_CODE_BASE);
  521.                 }
  522.                 print_char('=');
  523.                 print_val(eqtb[n].i);
  524.         } else if (n <= EQTB_SIZE) {
  525.                 if (n < SCALED_BASE)
  526.                         print_length_param(n - DIMEN_BASE);
  527.                 else {
  528.                         print_esc("dimen");
  529.                         print_int(n - SCALED_BASE);
  530.                 }
  531.                 print_char('=');
  532.                 print_scaled(eqtb[n].sc);
  533.                 print("pt");
  534.         } else print_char('?');
  535. }
  536. #endif
  537.  
  538. init_eq ()
  539. {
  540.         int             k;
  541.  
  542.         for (k = 0; k <= EQTB_SIZE - INT_BASE; incr(k))
  543.                 xeq_level[k] = LEVEL_ONE;
  544.  
  545. #ifdef INIT
  546.         eq_type(UNDEFINED_CONTROL_SEQUENCE) = UNDEFINED_CS;
  547.         equiv(UNDEFINED_CONTROL_SEQUENCE) = NULL;
  548.         eq_level(UNDEFINED_CONTROL_SEQUENCE) = LEVEL_ZERO;
  549.         for (k = ACTIVE_BASE; k < UNDEFINED_CONTROL_SEQUENCE; incr(k))
  550.                 eqtb[k]= eqtb[UNDEFINED_CONTROL_SEQUENCE];
  551.                         
  552.         equiv(GLUE_BASE) = zero_glue;
  553.         eq_level(GLUE_BASE) = LEVEL_ONE;
  554.         eq_type(GLUE_BASE) = GLUE_REF;
  555.         for (k = GLUE_BASE + 1; k < LOCAL_BASE; incr(k))
  556.                 eqtb[k] = eqtb[GLUE_BASE];
  557.         glue_ref_count(zero_glue) += LOCAL_BASE - GLUE_BASE;
  558.  
  559.         par_shape_ptr = NULL;
  560.         eq_type(PAR_SHAPE_LOC) = SHAPE_REF;
  561.         eq_level(PAR_SHAPE_LOC)= LEVEL_ONE;
  562.         for (k = OUTPUT_ROUTINE_LOC; k < TOKS_BASE + 256; incr(k))
  563.                 eqtb[k] = eqtb[UNDEFINED_CONTROL_SEQUENCE];
  564.         box(0) = NULL;
  565.         eq_type(BOX_BASE) = BOX_REF;
  566.         eq_level(BOX_BASE) = LEVEL_ONE;
  567.         for (k = BOX_BASE + 1; k < BOX_BASE + 256; incr(k))
  568.                 eqtb[k] = eqtb[BOX_BASE];
  569.         cur_font = NULL_FONT;
  570.         eq_type(CUR_FONT_LOC) = DATA;
  571.         eq_level(CUR_FONT_LOC) = LEVEL_ONE;
  572.         for (k = MATH_FONT_BASE; k < MATH_FONT_BASE + 48; incr(k))
  573.                 eqtb[k] = eqtb[CUR_FONT_LOC];
  574.         equiv(CAT_CODE_BASE) = 0;
  575.         eq_type(CAT_CODE_BASE) = DATA;
  576.         eq_level(CAT_CODE_BASE) = LEVEL_ONE;
  577.         for (k = CAT_CODE_BASE; k < INT_BASE; incr(k))
  578.                 eqtb[k] = eqtb[CAT_CODE_BASE];
  579.         for (k = 0; k <= 127; incr(k)) {
  580.                 cat_code(k) = OTHER_CHAR;
  581.                 math_code(k) = hi(k);
  582.                 sf_code(k) = 1000;
  583.         }
  584.         cat_code(CARRIAGE_RETURN) = CAR_RET;
  585.         cat_code(' ') = SPACER;
  586.         cat_code('^') = SUP_MARK;
  587.         cat_code('\\') = ESCAPE;
  588.         cat_code('%') = COMMENT;
  589.         cat_code(INVALID_CODE) = INVALID_CHAR;
  590.         cat_code(NULL_CODE) = IGNORE;
  591.         for (k = '0'; k <= '9'; incr(k))
  592.                 math_code(k) = hi(k + VAR_CODE);
  593.         for (k = 'A'; k <= 'Z'; incr(k)) {
  594.                 cat_code(k) = cat_code(k + 'a' - 'A') = LETTER;
  595.                 math_code(k) = hi(k + VAR_CODE + 0x100);
  596.                 math_code(k + 'a' - 'A') = hi(k + 'a' - 'A'+ VAR_CODE + 0x100);
  597.                 lc_code(k) = lc_code(k + 'a' - 'A') = k + 'a' - 'A';
  598.                 uc_code(k) = uc_code(k + 'a' - 'A') = k;
  599.                 sf_code(k) = 999;
  600.         }
  601.         for (k = INT_BASE; k < DEL_CODE_BASE; incr(k))
  602.                 eqtb[k].i = 0;
  603.         mag = 1000;
  604.         tolerance = 10000;
  605.         hang_after = 1;
  606.         max_dead_cycles = 25;
  607.         escape_char = '\\';
  608.         end_line_char = CARRIAGE_RETURN;
  609.         for (k = 0; k <= 127; incr(k))
  610.                 del_code(k) = -1;
  611.         del_code('.') = 0;
  612.         for (k = DIMEN_BASE; k <= EQTB_SIZE; incr(k))
  613.                 eqtb[k].sc = 0;
  614. #endif
  615. }
  616.